/*
Scramble String Total Accepted: 32601 Total Submissions: 132882 My Submissions Question Solution
Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

great
/    \
gr    eat
/ \    /  \
g   r  e   at
/ \
a   t
To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

rgeat
/    \
rg    eat
/ \    /  \
r   g  e   at
/ \
a   t
We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

rgtae
/    \
rg    tae
/ \    /  \
r   g  ta  e
/ \
t   a
We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.


*/
#include <iostream>
#include "print.h"
#include <vector>
#include <map>
#include <stack>
#include <algorithm>

using namespace std;


/***/
//Definition for an interval.
struct Interval {
	int start;
	int end;
	Interval() : start(0), end(0) {}
	Interval(int s, int e) : start(s), end(e) {}
};
class Solution {
public:
	bool isScramble(string s1, string s2) {

		if (s1.size() != s2.size())
		{
			return false;
		}
		if (s1.size() == 0&&s2.size()==0)
		{
			return true;
		}




	}

};



int main()
{
	int a[] = { 2, 1, 5, 6, 2, 3 };
	vector<int> nums(a, a + sizeof(a) / sizeof(int));

	char b[] = { '1' };
	vector<char> rows(b, b + sizeof(b) / sizeof(char));

	vector<vector<char>> dicts;

	dicts.push_back(rows);

	Solution s;

	//int res = s.maximalRectangle(dicts);


	system("pause");
	return 0;
}